Django Adminin Voiman Vapauttaminen: Mukautetut Admin-toiminnot Selitettynä

            # myapp/models.py
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    is_discounted = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

            # myapp/admin.py
from django.contrib import admin, messages
from django.db.models import QuerySet
from django.http import HttpRequest
from .models import Product

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'price', 'is_discounted', 'created_at')
    list_filter = ('is_discounted', 'created_at')
    search_fields = ('name',)

    # Määritellään mukautettu admin-toimintofunktio
    def make_discounted(self, request: HttpRequest, queryset: QuerySet):
        updated_count = queryset.update(is_discounted=True)
        self.message_user(
            request,
            f"{updated_count} tuotetta merkittiin onnistuneesti alennetuiksi.",
            messages.SUCCESS
        )
    make_discounted.short_description = "Merkitse valitut tuotteet alennetuiksi"

    # Rekisteröidään toiminto ModelAdminiin
    actions = [make_discounted]

            

              
                Copy
              
            
          

            # myapp/models.py (oletetaan Post-malli)
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    status = models.CharField(max_length=20, default='draft', choices=[
        ('draft', 'Luonnos'),
        ('pending', 'Tarkistettavana'),
        ('approved', 'Hyväksytty'),
        ('rejected', 'Hylätty'),
    ])
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

            

              
                Copy
              
            
          

            # myapp/forms.py
from django import forms

class ConfirmationForm(forms.Form):
    confirm = forms.BooleanField(
        label="Oletko varma, että haluat suorittaa tämän toiminnon?",
        required=True,
        widget=forms.HiddenInput # Hoidamme näytön mallissa
    )
    _selected_action = forms.CharField(widget=forms.HiddenInput)
    action = forms.CharField(widget=forms.HiddenInput)

            

              
                Copy
              
            
          

            # myapp/admin.py
from django.contrib import admin, messages
from django.db.models import QuerySet
from django.http import HttpRequest, HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from .models import Post
from .forms import ConfirmationForm

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'status', 'created_at')
    list_filter = ('status',)
    search_fields = ('title',)

    def mark_posts_approved(self, request: HttpRequest, queryset: QuerySet) -> HttpResponseRedirect | None:
        # Tarkistetaan, onko käyttäjä vahvistanut toiminnon
        if 'apply' in request.POST:
            form = ConfirmationForm(request.POST)
            if form.is_valid():
                updated_count = queryset.update(status='approved')
                self.message_user(
                    request,
                    f"{updated_count} julkaisua merkittiin onnistuneesti hyväksytyiksi.",
                    messages.SUCCESS
                )
                return HttpResponseRedirect(request.get_full_path())
        
        # Jos ei vahvistettu, tai GET-pyyntö, näytetään vahvistussivu
        else:
            # Tallennetaan valittujen objektien ensisijaiset avaimet piilotettuun kenttään
            # Tämä on välttämätöntä valinnan välittämiseksi vahvistussivun yli
            context = self.admin_site.each_context(request)
            context['queryset'] = queryset
            context['form'] = ConfirmationForm(initial={
                '_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME),
                'action': 'mark_posts_approved',
            })
            context['action_name'] = self.mark_posts_approved.short_description
            context['title'] = _("Vahvista toiminto")

            # Renderöidään mukautettu vahvistusmalli
            return render(request, 'admin/confirmation_action.html', context)

    mark_posts_approved.short_description = _("Merkitse valitut julkaisut hyväksytyiksi")

    actions = [mark_posts_approved]

            

              
                Copy
              
            
          

            {# templates/admin/confirmation_action.html #}
{% extends "admin/base_site.html" %}
{% load i18n admin_urls static admin_modify %}

{% block extrastyle %}{{ block.super }}
    
{% endblock %}

{% block content %}
    

        

            {% csrf_token %}
            
{{ action_name }}
            
Olet suorittamassa toimintoa "{{ action_name }}" seuraaville {{ queryset.count }} objektille:
            

                {% for obj in queryset %}
                    
{{ obj }}
                {% endfor %}
            
            
Oletko täysin varma, että haluat jatkaa?

            {{ form.as_p }}

            
            {% for item in form._selected_action.value %}
                
            {% endfor %}

            

                
                
            
        
    
{% endblock %}

            

              
                Copy
              
            
          

            # myapp/forms.py
from django import forms
from .models import Post

class ChangePostStatusForm(forms.Form):
    _selected_action = forms.CharField(widget=forms.HiddenInput)
    action = forms.CharField(widget=forms.HiddenInput)

    new_status = forms.ChoiceField(
        label="Uusi tila",
        choices=Post.STATUS_CHOICES, # Olettaen, että STATUS_CHOICES on määritelty Post-mallissa
        required=True
    )
    comment = forms.CharField(
        label="Syy/Kommentti (valinnainen)",
        required=False,
        widget=forms.Textarea(attrs={'rows': 3})
    )

# Lisää STATUS_CHOICES Post-malliin
# myapp/models.py
from django.db import models

class Post(models.Model):
    STATUS_CHOICES = [
        ('draft', 'Luonnos'),
        ('pending', 'Tarkistettavana'),
        ('approved', 'Hyväksytty'),
        ('rejected', 'Hylätty'),
    ]
    title = models.CharField(max_length=255)
    content = models.TextField()
    status = models.CharField(max_length=20, default='draft', choices=STATUS_CHOICES)
    comment_history = models.TextField(blank=True, null=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

            

              
                Copy
              
            
          

            # myapp/admin.py (jatkoa)
from django.contrib import admin, messages
from django.db.models import QuerySet
from django.http import HttpRequest, HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from .models import Post
from .forms import ChangePostStatusForm # Tuodaan uusi lomake

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'status', 'created_at')
    list_filter = ('status',)
    search_fields = ('title',)

    # Olemassa oleva mark_posts_approved toiminto...

    def change_post_status_with_comment(self, request: HttpRequest, queryset: QuerySet) -> HttpResponseRedirect | None:
        form = None
        if 'apply' in request.POST:
            form = ChangePostStatusForm(request.POST)
            if form.is_valid():
                new_status = form.cleaned_data['new_status']
                comment = form.cleaned_data['comment']

                updated_count = 0
                for post in queryset:
                    post.status = new_status
                    if comment:
                        post.comment_history = (post.comment_history or '') + f"\n[{request.user.username}] muutettu tilaan {new_status} kommentilla: {comment}"
                    post.save()
                    updated_count += 1

                self.message_user(
                    request,
                    f"{updated_count} julkaisun tila muutettiin tilaan '{new_status}' ja kommentti lisättiin.",
                    messages.SUCCESS
                )
                return HttpResponseRedirect(request.get_full_path())
        
        # Jos ei vahvistettu, tai GET-pyyntö, näytetään syöttölomake
        if not form:
            form = ChangePostStatusForm(initial={
                '_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME),
                'action': 'change_post_status_with_comment',
            })

        context = self.admin_site.each_context(request)
        context['queryset'] = queryset
        context['form'] = form
        context['action_name'] = self.change_post_status_with_comment.short_description
        context['title'] = _("Muuta julkaisun tilaa ja lisää kommentti")

        return render(request, 'admin/change_status_action.html', context)

    change_post_status_with_comment.short_description = _("Muuta valittujen julkaisujen tilaa (kommentilla)")

    actions = [
        mark_posts_approved,
        change_post_status_with_comment
    ]

            

              
                Copy
              
            
          

            {# templates/admin/change_status_action.html #}
{% extends "admin/base_site.html" %}
{% load i18n admin_urls static admin_modify %}

{% block extrastyle %}{{ block.super }}
    
{% endblock %}

{% block content %}
    

        

            {% csrf_token %}
            
{{ action_name }}
            
Olet muuttamassa tilan seuraaville {{ queryset.count }} objektille:
            

                {% for obj in queryset %}
                    
{{ obj }}
                {% endfor %}
            
            
Valitse uusi tila ja lisää valinnainen kommentti:

            {% for field in form %}
                {% if field.is_hidden %}
                    {{ field }}
                {% else %}
                    

                        {{ field.errors }}
                        {{ field.label_tag }}
                        {{ field }}
                        {% if field.help_text %}
{{ field.help_text }}
{% endif %}
                    
                {% endif %}
            {% endfor %}

            

                
                
            
        
    
{% endblock %}

            

              
                Copy
              
            
          

            # myapp/admin.py (jatkoa)
import requests # Sinun tulee asentaa requests: pip install requests
# ... muut tuonnit ...

# Olettaen aiemman ProductAdminin

class ProductAdmin(admin.ModelAdmin):
    # ... olemassa olevat list_display, list_filter, search_fields ...

    def sync_products_to_external_ims(self, request: HttpRequest, queryset: QuerySet) -> HttpResponseRedirect | None:
        # Tarkista vahvistus (samankaltainen kuin edellisissä esimerkeissä, jos tarpeen)
        if 'apply' in request.POST:
            # Simuloidaan ulkoista API-päätepistettä
            EXTERNAL_IMS_API_URL = "https://api.example.com/v1/products/sync/"
            API_KEY = "your_secret_api_key" # Todellisessa sovelluksessa käytä settings.py:tä tai ympäristömuuttujia

            successful_syncs = 0
            failed_syncs = []

            for product in queryset:
                data = {
                    "product_id": product.id,
                    "name": product.name,
                    "price": str(product.price), # Muunnetaan Decimal merkkijonoksi JSON:ia varten
                    "is_discounted": product.is_discounted,
                    # Lisää muu relevantti tuotetieto
                }
                headers = {
                    "Authorization": f"Bearer {API_KEY}",
                    "Content-Type": "application/json"
                }
                
                try:
                    response = requests.post(EXTERNAL_IMS_API_URL, json=data, headers=headers, timeout=5) # 5 sekunnin aikakatkaisu
                    response.raise_for_status() # Nostaa HTTPErrorin virheellisille vastauksille (4xx tai 5xx)
                    successful_syncs += 1
                except requests.exceptions.RequestException as e:
                    failed_syncs.append(f"Tuote {product.name} (ID: {product.id}): {e}")
                except Exception as e:
                    failed_syncs.append(f"Tuote {product.name} (ID: {product.id}): Odottamaton virhe: {e}")

            if successful_syncs > 0:
                self.message_user(
                    request,
                    f"{successful_syncs} tuotetta synkronoitiin onnistuneesti ulkoiseen IMS:iin.",
                    messages.SUCCESS
                )
            if failed_syncs:
                error_message = f"Epäonnistui {len(failed_syncs)} tuotteen synkronointi:\n" + "\n".join(failed_syncs)
                self.message_user(request, error_message, messages.ERROR)
            
            return HttpResponseRedirect(request.get_full_path())

        # Alkuperäinen GET-pyyntö tai ei-apply POST-pyyntö: näytä vahvistus (jos halutaan)
        context = self.admin_site.each_context(request)
        context['queryset'] = queryset
        context['form'] = ConfirmationForm(initial={
            '_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME),
            'action': 'sync_products_to_external_ims',
        })
        context['action_name'] = self.sync_products_to_external_ims.short_description
        context['title'] = _("Vahvista datan synkronointi")

        return render(request, 'admin/confirmation_action.html', context) # Käytetään uudelleen vahvistusmallia

    sync_products_to_external_ims.short_description = _("Synkronoi valitut tuotteet ulkoiseen IMS:iin")

    actions = [
        # ... muut toiminnot ...
        sync_products_to_external_ims,
    ]

            

              
                Copy
              
            
          

            # myapp/admin.py (jatkoa)
import csv
from django.http import HttpResponse
# ... muut tuonnit ...

class PostAdmin(admin.ModelAdmin):
    # ... olemassa olevat list_display, list_filter, search_fields, actions ...

    def export_posts_as_csv(self, request: HttpRequest, queryset: QuerySet) -> HttpResponse:
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="posts_export.csv"'

        writer = csv.writer(response)
        # Kirjoitetaan otsikkorivi
        writer.writerow(['Otsikko', 'Tila', 'Luotu', 'Sisällön esikatselu'])

        for post in queryset:
            writer.writerow([
                post.title,
                post.get_status_display(), # Käytä get_FOO_display()-metodia valintakentille
                post.created_at.strftime("%Y-%m-%d %H:%M:%S"),
                post.content[:100] + '...' if len(post.content) > 100 else post.content # Katkaistaan pitkät sisällöt
            ])
        
        self.message_user(
            request,
            f"{queryset.count()} julkaisua vietiin onnistuneesti CSV:iin.",
            messages.SUCCESS
        )
        return response

    export_posts_as_csv.short_description = _("Vie valitut julkaisut CSV:nä")

    actions = [
        # ... muut toiminnot ...
        export_posts_as_csv,
    ]

            

              
                Copy
              
            
          

            # myproject/celery.py (standardi Celery-asetus)
import os
from celery import Celery

# Asetetaan oletus Django-asetusmoduuli 'celery'-ohjelmalle.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

app = Celery('myproject')

# Käyttämällä merkkijonoa tässä työntekijä ei joudu
# picklaamaan oliota, kun käytetään Windowsia.
app.config_from_object('django.conf:settings', namespace='CELERY')

# Ladataan tehtävämoduulit kaikista rekisteröidyistä Django-sovelluskonfiguraatioista.
app.autodiscover_tasks()

@app.task(bind=True)
def debug_task(self):
    print(f'Request: {self.request!r}')

            

              
                Copy
              
            
          

            # myapp/tasks.py
import requests
from celery import shared_task
from django.contrib.auth import get_user_model
from django.apps import apps

@shared_task
def sync_product_to_external_ims_task(product_id, admin_user_id):
    Product = apps.get_model('myapp', 'Product')
    User = get_user_model()

    try:
        product = Product.objects.get(pk=product_id)
        admin_user = User.objects.get(pk=admin_user_id)

        EXTERNAL_IMS_API_URL = "https://api.example.com/v1/products/sync/"
        API_KEY = "your_secret_api_key" # Käytä ympäristömuuttujia tai Django-asetuksia

        data = {
            "product_id": product.id,
            "name": product.name,
            "price": str(product.price),
            "is_discounted": product.is_discounted,
        }
        headers = {
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        }

        response = requests.post(EXTERNAL_IMS_API_URL, json=data, headers=headers, timeout=10)
        response.raise_for_status()
        
        # Kirjaa onnistuminen (esim. Django-lokkeihin tai tiettyyn malliin seurantaa varten)
        print(f"Tuote {product.name} (ID: {product.id}) synkronoitu onnistuneesti käyttäjän {admin_user.username} toimesta.")

    except Product.DoesNotExist:
        print(f"Tuotetta ID:llä {product_id} ei löytynyt.")
    except User.DoesNotExist:
        print(f"Ylläpitäjää ID:llä {admin_user_id} ei löytynyt.")
    except requests.exceptions.RequestException as e:
        print(f"API-synkronointi epäonnistui tuotteelle {product_id}: {e}")
    except Exception as e:
        print(f"Odottamaton virhe synkronoinnin aikana tuotteelle {product_id}: {e}")


            

              
                Copy
              
            
          

            # myapp/admin.py (jatkoa)
from django.contrib import admin, messages
from django.db.models import QuerySet
from django.http import HttpRequest, HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from .models import Product # Oletetaan aiempi Product-malli
from .tasks import sync_product_to_external_ims_task # Tuodaan Celery-tehtäväsi

class ProductAdmin(admin.ModelAdmin):
    # ... olemassa olevat list_display, list_filter, search_fields ...

    def async_sync_products_to_external_ims(self, request: HttpRequest, queryset: QuerySet) -> HttpResponseRedirect | None:
        if 'apply' in request.POST:
            admin_user_id = request.user.id
            for product in queryset:
                # Jonotetaan tehtävä jokaiselle valitulle tuotteelle
                sync_product_to_external_ims_task.delay(product.id, admin_user_id)
            
            self.message_user(
                request,
                f"{queryset.count()} tuotteen synkronointitehtävät on jonotettu.",
                messages.SUCCESS
            )
            return HttpResponseRedirect(request.get_full_path())

        # Alkuperäinen GET-pyyntö tai ei-apply POST-pyyntö: näytä vahvistus
        context = self.admin_site.each_context(request)
        context['queryset'] = queryset
        context['form'] = ConfirmationForm(initial={
            '_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME),
            'action': 'async_sync_products_to_external_ims',
        })
        context['action_name'] = self.async_sync_products_to_external_ims.short_description
        context['title'] = _("Vahvista asynkroninen datan synkronointi")

        return render(request, 'admin/confirmation_action.html', context) # Käytetään uudelleen vahvistusmallia

    async_sync_products_to_external_ims.short_description = _("Jonoa asynkroninen synkronointi valituille tuotteille IMS:iin")

    actions = [
        # ... muut toiminnot ...
        async_sync_products_to_external_ims,
    ]

            

              
                Copy
              
            
          

            def sensitive_action(self, request, queryset):
    if not request.user.has_perm('myapp.can_perform_sensitive_action'):
        self.message_user(request, _("Sinulla ei ole oikeutta suorittaa tätä toimintoa."), messages.ERROR)
        return HttpResponseRedirect(request.get_full_path())
    # ... arkaluonteisen toiminnon logiikka ...

            

              
                Copy
              
            
          

            # myapp/models.py
class Product(models.Model):
    # ... kentät ...
    class Meta:
        permissions = [
            ("can_perform_sensitive_action", "Voi suorittaa arkaluonteisen tuotetoiminnon"),
        ]

            

              
                Copy
              
            
          

            # myapp/admin.py
class ProductAdmin(admin.ModelAdmin):
    # ... toimintojen määrittely ...

    def get_actions(self, request: HttpRequest):
        actions = super().get_actions(request)
        # Poista 'make_discounted'-toiminto, jos käyttäjällä ei ole spesifiä oikeutta
        if not request.user.has_perm('myapp.change_product'): # Tai mukautettu oikeus kuten 'can_discount_product'
            if 'make_discounted' in actions:
                del actions['make_discounted']
        return actions

            

              
                Copy
              
            
          

            # myapp/admin_actions.py
from django.contrib import messages
from django.http import HttpRequest, HttpResponseRedirect
from django.db.models import QuerySet

def mark_as_active(modeladmin, request: HttpRequest, queryset: QuerySet):
    updated = queryset.update(is_active=True)
    modeladmin.message_user(request, f"{updated} kohdetta merkittiin aktiivisiksi.", messages.SUCCESS)
mark_as_active.short_description = "Merkitse valitut aktiivisiksi"

            

              
                Copy
              
            
          

            # myapp/admin.py
from django.contrib import admin
from .models import MyModel
from .admin_actions import mark_as_active

@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    list_display = ('name', 'is_active')
    actions = [mark_as_active]

            

              
                Copy
              
            
          

            # myapp/tests.py
from django.test import TestCase, Client
from django.contrib.auth import get_user_model
from django.urls import reverse
from django.contrib import admin
from .models import Product
from .admin import ProductAdmin # Tuodaan ModelAdminisi

User = get_user_model()

class ProductAdminActionTests(TestCase):
    def setUp(self):
        self.admin_user = User.objects.create_superuser('admin', 'admin@example.com', 'password')
        self.client = Client()
        self.client.login(username='admin', password='password')

        self.p1 = Product.objects.create(name="Tuote A", price=10.00, is_discounted=False)
        self.p2 = Product.objects.create(name="Tuote B", price=20.00, is_discounted=False)
        self.p3 = Product.objects.create(name="Tuote C", price=30.00, is_discounted=True)

        self.admin_site = admin.AdminSite()
        self.model_admin = ProductAdmin(Product, self.admin_site)

    def test_make_discounted_action(self):
        # Simuloidaan tuotteiden valintaa ja toiminnon suorittamista
        change_list_url = reverse('admin:myapp_product_changelist')
        response = self.client.post(change_list_url, {
            admin.ACTION_CHECKBOX_NAME: [self.p1.pk, self.p2.pk],
            'action': 'make_discounted',
            'index': 0, # Vaaditaan joidenkin Django adminin sisäisten logiikoiden vuoksi
        }, follow=True)

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, '2 tuotetta merkittiin onnistuneesti alennetuiksi.')
        
        self.p1.refresh_from_db()
        self.p2.refresh_from_db()
        self.p3.refresh_from_db()

        self.assertTrue(self.p1.is_discounted)
        self.assertTrue(self.p2.is_discounted)
        self.assertTrue(self.p3.is_discounted) # Tämä oli jo alennettu

    def test_make_discounted_action_confirmation(self):
        # Vahvistuksen vaativien toimintojen osalta testattaisiin kaksivaiheinen prosessi
        change_list_url = reverse('admin:myapp_post_changelist') # Oletetaan Post-malli vahvistusesimerkkiä varten
        post1 = Post.objects.create(title='Testijulkaisu 1', content='...', status='draft')
        post2 = Post.objects.create(title='Testijulkaisu 2', content='...', status='draft')

        # Vaihe 1: Vahvistussivun pyytäminen
        response = self.client.post(change_list_url, {
            admin.ACTION_CHECKBOX_NAME: [post1.pk, post2.pk],
            'action': 'mark_posts_approved',
            'index': 0,
        })
        self.assertEqual(response.status_code, 200)
        self.assertIn(b"Vahvista toiminto", response.content) # Tarkistetaan, että vahvistussivu renderöidään

        # Vaihe 2: Vahvistuslomakkeen lähettäminen
        response = self.client.post(change_list_url, {
            admin.ACTION_CHECKBOX_NAME: [post1.pk, post2.pk],
            'action': 'mark_posts_approved',
            'apply': 'Kyllä, olen varma',
            'confirm': 'on', # Arvo checkboxille, jos renderöity checkboxina
            '_selected_action': [str(post1.pk), str(post2.pk)], # Täytyy välittää takaisin lomakkeesta
            'index': 0,
        }, follow=True)

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, '2 julkaisua merkittiin onnistuneesti hyväksytyiksi.')

        post1.refresh_from_db()
        post2.refresh_from_db()
        self.assertEqual(post1.status, 'approved')
        self.assertEqual(post2.status, 'approved')

            

              
                Copy